const express = require('express');
const router = express.Router();
const { verifyAdmin } = require('../middleware/auth');
const systemMonitor = require('../services/systemMonitor');
const { exec } = require('child_process');
const util = require('util');

const execPromise = util.promisify(exec);

/**
 * @route   GET /api/system/info
 * @desc    获取系统基本信息
 * @access  私有
 */
router.get('/info', async (req, res) => {
  try {
    const systemInfo = await systemMonitor.getSystemInfo();
    res.json(systemInfo);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   GET /api/system/processes
 * @desc    获取系统进程列表
 * @access  私有
 */
router.get('/processes', async (req, res) => {
  try {
    const processes = await systemMonitor.getProcessList();
    res.json(processes);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   POST /api/system/process/kill
 * @desc    结束指定进程
 * @access  私有 (仅管理员)
 */
router.post('/process/kill', verifyAdmin, async (req, res) => {
  try {
    const { pid } = req.body;
    
    if (!pid) {
      return res.status(400).json({ error: '需要提供进程ID' });
    }
    
    await execPromise(`kill -9 ${pid}`);
    res.json({ message: `进程 ${pid} 已终止` });
  } catch (error) {
    res.status(500).json({ error: `无法终止进程: ${error.message}` });
  }
});

/**
 * @route   GET /api/system/services
 * @desc    获取系统服务状态
 * @access  私有
 */
router.get('/services', async (req, res) => {
  try {
    const services = await systemMonitor.getServicesStatus();
    res.json(services);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   POST /api/system/services/action
 * @desc    管理系统服务（启动/停止/重启）
 * @access  私有 (仅管理员)
 */
router.post('/services/action', verifyAdmin, async (req, res) => {
  try {
    const { service, action } = req.body;
    
    if (!service || !action) {
      return res.status(400).json({ error: '需要提供服务名称和操作类型' });
    }
    
    // 验证操作类型
    if (!['start', 'stop', 'restart', 'status'].includes(action)) {
      return res.status(400).json({ error: '无效的操作类型' });
    }
    
    // 验证服务名称（防止命令注入）
    if (!/^[a-zA-Z0-9\-\_\.]+$/.test(service)) {
      return res.status(400).json({ error: '无效的服务名称' });
    }
    
    const { stdout } = await execPromise(`systemctl ${action} ${service}`);
    res.json({ 
      message: `服务 ${service} ${action === 'start' ? '已启动' : action === 'stop' ? '已停止' : '已重启'}`,
      output: stdout
    });
  } catch (error) {
    res.status(500).json({ error: `操作失败: ${error.message}` });
  }
});

/**
 * @route   GET /api/system/network/connections
 * @desc    获取网络连接信息
 * @access  私有
 */
router.get('/network/connections', async (req, res) => {
  try {
    const connections = await systemMonitor.getNetworkConnections();
    res.json(connections);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

/**
 * @route   POST /api/system/reboot
 * @desc    重启系统
 * @access  私有 (仅管理员)
 */
router.post('/reboot', verifyAdmin, async (req, res) => {
  try {
    // 发送响应后执行重启，给前端时间处理响应
    res.json({ message: '正在重启系统...' });
    
    // 延迟2秒后执行重启
    setTimeout(() => {
      exec('shutdown -r now', (error) => {
        if (error) {
          console.error(`重启失败: ${error}`);
        }
      });
    }, 2000);
  } catch (error) {
    res.status(500).json({ error: `重启失败: ${error.message}` });
  }
});

/**
 * @route   POST /api/system/shutdown
 * @desc    关闭系统
 * @access  私有 (仅管理员)
 */
router.post('/shutdown', verifyAdmin, async (req, res) => {
  try {
    // 发送响应后执行关机，给前端时间处理响应
    res.json({ message: '正在关闭系统...' });
    
    // 延迟2秒后执行关机
    setTimeout(() => {
      exec('shutdown now', (error) => {
        if (error) {
          console.error(`关机失败: ${error}`);
        }
      });
    }, 2000);
  } catch (error) {
    res.status(500).json({ error: `关机失败: ${error.message}` });
  }
});

/**
 * @route   GET /api/system/update/check
 * @desc    检查系统更新
 * @access  私有 (仅管理员)
 */
router.get('/update/check', verifyAdmin, async (req, res) => {
  try {
    // 适用于基于Debian的系统（如Ubuntu）
    const { stdout } = await execPromise('apt update && apt list --upgradable');
    
    const updates = stdout
      .split('\n')
      .filter(line => line.includes('upgradable'))
      .map(line => {
        const parts = line.split('/');
        return { package: parts[0].trim() };
      });
    
    res.json({
      updates,
      count: updates.length
    });
  } catch (error) {
    res.status(500).json({ error: `检查更新失败: ${error.message}` });
  }
});

/**
 * @route   POST /api/system/update/apply
 * @desc    应用系统更新
 * @access  私有 (仅管理员)
 */
router.post('/update/apply', verifyAdmin, async (req, res) => {
  try {
    // 发送响应，因为更新过程可能需要很长时间
    res.json({ message: '正在后台执行系统更新，这可能需要一些时间...' });
    
    // 执行更新
    exec('apt update && apt upgrade -y', (error, stdout, stderr) => {
      if (error) {
        console.error(`更新失败: ${error}`);
        return;
      }
      console.log(`更新输出: ${stdout}`);
    });
  } catch (error) {
    res.status(500).json({ error: `更新失败: ${error.message}` });
  }
});

module.exports = router; 